Search
======

You may enter several search criteria in this window.

   *     Search for

     Here you may enter the search pattern. You may (and must) use the
     known AMIGA patterns.  It is needed to enter infront of and behind
     the search string either a #? or a * if you want to look for
     partial strings!  This means, you have to input #?PartialString#?
     instead of PartialString. Let's say you want to search for first
     names that start with Mi, you have to enter Mi#?. If you want to
     look for cities that end in town, you have to enter #?town.

     The following patterns are supported:

    ?
          The question mark matches any single character. For example,
          the pattern matching string A?B matches any string that is
          three letters long, that starts with an A and ends with a B.

    #
          The number sign matches strings containing zero or more
          repetitions of the expression that immediately follows the #
          in the pattern matching string.  For example, the pattern
          matching string #A matches any string that consists of one or
          more of the A character.  The pattern matching string #?
          matches any non-NULL string.  The # can apply to entire
          substrings delimited by parentheses.  For example, the
          pattern string #(AB) matches any string consisting of one or
          more repetitions of the substring AB (AB, ABAB, ABABAB,...).

    %
          Matches the NULL string.

    |
          This is the OR symbol.  This matches strings that contain the
          expressions on either side of the OR sign.  The expressions
          and the OR symbol need to be enclosed in parentheses.  For
          example, the pattern matching string (A|B) matches the string
          A or the string B.  The pattern matching string A(B|%|C)
          matches the strings AB, A, and AC.

    ~
          The tilde negates the expression that follows it.  All
          strings that do not match the expression that follows the
          tilde will match the expression with the tilde.  For example,
          the pattern matching string ~(#?.info) matches any string that
          does not match the string #?.info (does not end with the
          substring .info).

    *
          The star is provided as an synonym to #?.

    [ ]
          All characters within brackets indicate a character class.
          Any character in the character class qualifies.  Within a
          character class, a character range can be indicated by
          specifing the start and stop character, separated with a
          minus sign.  Note that character classes are case sensitive.
          If character classes are to be used in a case insensitive
          form, they should be translated to uppercase.  Here are some
          examples:

         [ACF]#?
               matches strings starting with A, C, or F

         [A-D]#?
               matches strings starting with A, B, C or D

         [~ACF]#?
               matches strings not starting with A, C or F

    '
          The quote character neutralizes the special meaning of a
          special character.  Here are some examples:

         '#'?
               matches only the literal string #?

         '?(A|B|C|%)'# matches the literal strings ?#, ?A#,
               ?B#, ?C#

         "
               The quote itself

    ( )
          Parentheses group special characters.  The expression within
          the parentheses is a subpattern.

   *     Ignore case

     If the box is "checked", the search will not be case sensitive. If
     the box is empty however, case will be noticed.

   *     All

     Select all fields.

   *     None

     Deselects all fields.

   *     Fields to search

     You may select which fields you would like to search through. It is
     possible to toggle each single field. The default is to search
     trough all fields.

   *     Search

     Search starts the searching. If a matching item is found, the
     address listview scrolls to the corresponding place and the
     matching entry becomes the current one.

   *     Cancel

     Cancel terminates the search.